package com.itheima.leetcode.od.b.bf;

import java.util.*;
import java.util.stream.Collectors;

/**
 * (B卷,200分)- 最长的顺子（Java & JS & Python）
 * <p>
 * 题目描述
 * <p>
 * 斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法“跑得快”改编的，如今已风靡整个中国，并流行于互联网上。
 * <p>
 * 牌型：单顺，又称顺子，最少5张牌，最多12张牌(3…A)不能有2，也不能有大小王，不计花色。
 * <p>
 * 例如： 3-4-5-6-7-8，7-8-9-10-J-Q，3-4-5-6-7-8-9-10-J-Q-K-A
 * <p>
 * 可用的牌 3<4<5<6<7<8<9<10<J<Q<K<A<2<B(小王)<C(大王)，每种牌除大小王外有四种花色
 * (共有13×4+2张牌)
 * <p>
 * 输入：
 * 手上有的牌
 * 已经出过的牌(包括对手出的和自己出的牌)
 * 输出：
 * 对手可能构成的最长的顺子(如果有相同长度的顺子，输出牌面最大的那一个)，
 * 如果无法构成顺子，则输出 NO-CHAIN。
 * <p>
 * 输入描述
 * <p>
 * 输入的第一行为当前手中的牌
 * <p>
 * 输入的第二行为已经出过的牌
 * <p>
 * 输出描述
 * <p>
 * 最长的顺子
 * <p>
 * 用例
 * <p>
 * 输入	3-3-3-3-4-4-5-5-6-7-8-9-10-J-Q-K-A
 * 4-5-6-7-8-8-8
 * 输出	9-10-J-Q-K-A
 * 说明	无
 * <p>
 * 输入	3-3-3-3-8-8-8-8
 * K-K-K-K
 * 输出	NO-CHAIN
 * 说明	剩余的牌无法构成顺子
 */
public class LongestStraight {
    public static void main(String[] args) {
        /*Scanner scanner = new Scanner(System.in);
        String[] handCards = scanner.nextLine().split("-");
        String[] playedCards = scanner.nextLine().split("-");
        scanner.close();*/

        String[] handCards = "3-3-3-3-4-4-5-5-6-7-8-9-10-J-Q-K-A".split("-");
        String[] playedCards = "4-5-6-7-8-8-8".split("-");
        /*String[] handCards = "3-3-3-3-8-8-8-8".split("-");
        String[] playedCards = "K-K-K-K".split("-");*/

        System.out.println(getResult(handCards, playedCards));
    }

    private static String getResult(String[] handCards, String[] playedCards) {
        Map<String, Integer> rankMap = new HashMap<>();
        String[] ranks = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "B", "C"};
        for (int i = 0; i < ranks.length; i++) {
            rankMap.put(ranks[i], i + 3);
        }

        Map<Integer, String> reverseRankMap = rankMap.entrySet()
                .stream()
                .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));

        Map<Integer, Integer> cardCount = new HashMap<>();
        for (int i = 3; i <= 15; i++) {
            cardCount.put(i, 4);
        }
        cardCount.put(16, 1);  // 小王
        cardCount.put(17, 1);  // 大王

        int i = 0;
        List<String> allCards = new ArrayList<>();
        allCards.addAll(Arrays.asList(handCards));
        allCards.addAll(Arrays.asList(playedCards));

        while (i < allCards.size()) {
            int cardValue = rankMap.get(allCards.get(i));
            cardCount.put(cardValue, cardCount.get(cardValue) - 1);
            i++;
        }

        String bestChain = "NO-CHAIN";
        int maxSize = 0;

        for (int start = 3; start <= 10; start++) {
            List<String> sequence = new ArrayList<>();
            for (int end = start; end < 16; end++) { // 收尾操作，这里多加一次循环，是为了处理最后一次遍历的问题
                if (cardCount.get(end) > 0 && end < 15) {
                    sequence.add(reverseRankMap.get(end));
                } else {
                    if (sequence.size() >= 5 && sequence.size() >= maxSize) {
                        maxSize = sequence.size();
                        bestChain = sequence.stream().collect(Collectors.joining("-"));
                    }
                    break;
                }
            }
        }

        return bestChain;
    }
}